…ormats

Previously, the ValueOnly serialization was method based in the
server package. These changes shift the code from serve package to
the sdk, as ValueOnly serialiaztion is defined in Part 1 of the spec.
Additionally, I restructured the code to live inside a `JSONEncoder`
subclass, so it can be used the same way as `AASToJsonEncoder`.

Still TODO:
- Implement `level=core` serialization
- Integrate this serialiazer into the server

Functionality follows eclipse-basyx#649

Showcases collapse of rules and handler methods using converter and modifiers

These changes implement a core serialization for the `AASToJsonEncoder`
that is backward compatible to custom subclasses of this class.
For all five types, that are affected by core serialization, addtional
methods were introduced that call the standard serialization method
and afterwards serialize all children, omitting the grandchildren.

This solution allows us to pass the `deep` parameter via the `__init__()`
method, which helps to avoid addtional subclass constructs.

The `ValueOnlyJsonEncoder` overwrites these methods to also implement
core serialization. Test are written for both classes in core serialization
mode.

Fixes __init__ ordering by using local imports

Following API Specification Part 2

…iat/basyx-python-sdk into feat/serialization-formats

Previously, the order of elements in JSON arrays was
non-deterministic for the same AAS. This overcomplicated
easy change detection of serialized objects.

With these changes, this behavior is changed. All JSON
arrays are now ordered, either because the metamodel requires
them to be sorted (e.g. SubmodelElementList) or sorting is
done during serialization (e.g. elements of
SubmodelElementCollections are now ordered by their `idShort`).

The order of keys in the JSON objects is already defined by
their insertion order in the Python `dict`. From now on,
objects with equal content will result in identical JSON
representations.

Fixes eclipse-basyx#573

Address review comments on the ported test_value.py
General overhaul following metadata testing and encoder redesign

- Drop tests and helpers duplicating SDK Encoder tests
- Replace 501 extent test expecting functional blob toggle
- Add a shared value endpoint test base to enforce proper modifier combination handling
- Flag list endpoint shape with TODO for now

Replace the separate handlers for $metadata, $value, $reference and
$path with single handlers driven by the parsed serialization
modifiers, which now select the response encoder.

Extract the result serialization into a mixin, so each format can
combine it directly with its SDK encoder. Listings of
submodel-elements are wrapped so that each format controls the shape
of its result.

Filtering and pagination of $path listings is still to be resolved.

Previously, in path serialization the pagination was still applied
to the SubmodelElements. Because each SubmodelElement is mapped to
multiple idShortPath strings, the paginated results exceeded the
limit.

Now the pagination is done on the already encoded idShortPaths.
Therefore the `ResultPathJsonEncoder` is extended with a `iter_paths()`
method, that returns an iterator for the paths, that is then paginated
using the existing `_get_slice()`.

Elements added to a SubmodelElementList without an idShort get an
internal `generated_submodel_list_hack_...` idShort. Previously,
this could not leak because elements in SubmodelElementList were not
allowed to have idShorts. When this contstrain (AASd-120) was dropped,
this lead to the following problems:

- Normal + Metadata Serialization (JSON + XML):
  Previously the idShort of an element inside a SML was never serialized.
  This wrongly hid existing idShorts. To fix this, we introduce a central
  `serializable_id_short()` function that only hides generated idShorts
  of elements in SML as `None` and lets all other values pass.

- Path Serialization (JSON):
  When elements of a SML are serialized directly, their idShort leads
  the idShortPaths that are generated. At this point the generated
  isShorts could leak, so we use the `serializable_id_short()` helper
  and raise a `ValueError` on generated or missing idShorts.

- Server `POST .../submodel-elements/<idShortPath>`:
  When a new SubmodelElement is created the response header `Location`
  contians the address that should return this element. This was manually
  contructed from the new idShort, leaking generated values, which lead
  to a wrong address. We now use the `Referable.get_id_short_path_as_list()`
  method, which handles children of SML correctly.

Test cases are added, that ensure no generated idShorts are leaking
and all manually set idShorts are serialized.

- `limit=0` returned an empty page whose cursor points to the same start.
  `_get_slice` now rejects `limit < 1` with 400 for all routes.
- By-path `$path` on an element without idShort (child of a
  SubmodelElementList) raised a ValueError (500). It now responds with 400.
  List children with an idShort are still supported.
- Use a format client in all `$path` tests instead of the bare client.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>